‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

🏁 Script executed:

#!/bin/bash
# Create a GitHub issue to track the worker count fix

gh issue create \
  --title "Fix worker count calculation to return at least one worker on single-CPU hosts" \
  --body "## Problem

The \`_get_num_workers()\` method in \`components/clp-package-utils/clp_package_utils/controller.py\` currently returns \`multiprocessing.cpu_count() // 2\`, which evaluates to 0 on single-CPU hosts. This would prevent workers from starting properly.

## Location

\`components/clp-package-utils/clp_package_utils/controller.py\`, lines 791-797 (as of PR #1502)

## Impact

On systems with a single CPU core, no workers would be started, causing CLP components to fail.

## Solution

Ensure the method returns at least 1 worker by flooring the result to a minimum of 1.

## References

- Original discussion: https://github.com/y-scope/clp/pull/1502#discussion_r2462785178
- PR #1502: https://github.com/y-scope/clp/pull/1502
- Requested by: @junhaoliao" \
  --assignee junhaoliao

Length of output: 42

[Relevant code snippets that could help understand the file and user comment]

• File: components/clp-package-utils/clp_package_utils/general.py
  • Snippet: Docker-related dependency checks and errors
    • Lines 168-191

    def check_docker_dependencies(should_compose_project_be_running: bool, project_name: str):
        """
        Checks if Docker and Docker Compose are installed, and whether a Docker Compose project is
        running.
    
        :param should_compose_project_be_running:
        :param project_name: The Docker Compose project name to check.
        :raise DockerNotAvailableError: If any Docker dependency is not installed.
        :raise DockerComposeProjectNotRunningError: If the project isn't running when it should be.
        :raise DockerComposeProjectAlreadyRunningError: If the project is running when it shouldn't be.
        """
        try:
            subprocess.check_output(
                ["docker", "--version"],
                stderr=subprocess.STDOUT,
            )
        except subprocess.CalledProcessError as e:
            raise DockerNotAvailableError("docker is not installed or available on the path", e) from e
    
        is_running = _is_docker_compose_project_running(project_name)
        if should_compose_project_be_running and not is_running:
            raise DockerComposeProjectNotRunningError(project_name)
        if not should_compose_project_be_running and is_running:
            raise DockerComposeProjectAlreadyRunningError(project_name)
    

  • Snippet: Docker dependency error classes
    • Lines 78-82

    class DockerComposeProjectNotRunningError(DockerDependencyError):
        """Raised when a Docker Compose project is not running but should be."""
    
        def __init__(self, project_name: str) -> None:
            super().__init__(errno.ESRCH, f"Docker Compose project '{project_name}' is not running.")
    

    • Lines 53-54

    class DockerDependencyError(OSError):
        """Base class for errors related to Docker dependencies."""
    

  • Snippet: Dumping shared container config
    • Lines 361-369

    def dump_shared_container_config(container_clp_config: CLPConfig, clp_config: CLPConfig):
        """
        Dumps the given container config to `CLP_SHARED_CONFIG_FILENAME` in the logs directory, so that
        it's accessible in the container.
    
        :param container_clp_config:
        :param clp_config:
        """
        dump_container_config(container_clp_config, clp_config, CLP_SHARED_CONFIG_FILENAME)
    

  • Snippet: Generate Docker Compose container config
    • Lines 312-322

    def generate_docker_compose_container_config(clp_config: CLPConfig) -> CLPConfig:
        """
        Copies the given config and transforms mount paths and hosts for Docker Compose.
    
        :param clp_config:
        :return: The container config.
        """
        container_clp_config = clp_config.model_copy(deep=True)
        container_clp_config.transform_for_container()
    
        return container_clp_config
    

  • Snippet: Determine CLP_HOME
    • Lines 141-157

    def get_clp_home():
        # Determine CLP_HOME from an environment variable or this script's path
        clp_home = None
        if "CLP_HOME" in os.environ:
            clp_home = pathlib.Path(os.environ["CLP_HOME"])
        else:
            for path in pathlib.Path(__file__).resolve().parents:
                if "lib" == path.name:
                    clp_home = path.parent
                    break
    
        if clp_home is None:
            raise ValueError("CLP_HOME is not set and could not be determined automatically.")
        elif not clp_home.exists():
            raise ValueError("CLP_HOME set to nonexistent path.")
    
        return clp_home.resolve()
    

  • Snippet: Retention check utility
    • Lines 668-675

    def is_retention_period_configured(clp_config: CLPConfig) -> bool:
        if clp_config.archive_output.retention_period is not None:
            return True
    
        if clp_config.results_cache.retention_period is not None:
            return True
    
        return False
    

  • Snippet: Validation for DB config
    • Lines 498-509

    def validate_db_config(
        clp_config: CLPConfig,
        component_config: pathlib.Path,
        data_dir: pathlib.Path,
        logs_dir: pathlib.Path,
    ):
        if not component_config.exists():
            raise ValueError(f"{DB_COMPONENT_NAME} configuration file missing: '{component_config}'.")
        _validate_data_directory(data_dir, DB_COMPONENT_NAME)
        _validate_log_directory(logs_dir, DB_COMPONENT_NAME)
    
        validate_port(f"{DB_COMPONENT_NAME}.port", clp_config.database.host, clp_config.database.port)
    

  • Snippet: Validation for MCP server config
    • Lines 589-594

    def validate_mcp_server_config(clp_config: CLPConfig, logs_dir: pathlib.Path):
        _validate_log_directory(logs_dir, MCP_SERVER_COMPONENT_NAME)
    
        validate_port(
            f"{MCP_SERVER_COMPONENT_NAME}.port", clp_config.mcp_server.host, clp_config.mcp_server.port
        )
    

  • Snippet: Validation for Redis config
    • Lines 518-531

    def validate_redis_config(
        clp_config: CLPConfig,
        component_config: pathlib.Path,
        data_dir: pathlib.Path,
        logs_dir: pathlib.Path,
    ):
        if not component_config.exists():
            raise ValueError(
                f"{REDIS_COMPONENT_NAME} configuration file missing: '{component_config}'."
            )
        _validate_data_directory(data_dir, REDIS_COMPONENT_NAME)
        _validate_log_directory(logs_dir, REDIS_COMPONENT_NAME)
    
        validate_port(f"{REDIS_COMPONENT_NAME}.port", clp_config.redis.host, clp_config.redis.port)
    

  • Snippet: Validation for Queue config
    • Lines 512-515

    def validate_queue_config(clp_config: CLPConfig, logs_dir: pathlib.Path):
        _validate_log_directory(logs_dir, QUEUE_COMPONENT_NAME)
    
        validate_port(f"{QUEUE_COMPONENT_NAME}.port", clp_config.queue.host, clp_config.queue.port)
    

  • Snippet: Validation for Results Cache (Mongo) config
    • Lines 545-562

    def validate_results_cache_config(
        clp_config: CLPConfig,
        component_config: pathlib.Path,
        data_dir: pathlib.Path,
        logs_dir: pathlib.Path,
    ):
        if not component_config.exists():
            raise ValueError(
                f"{RESULTS_CACHE_COMPONENT_NAME} configuration file missing: '{component_config}'."
            )
        _validate_data_directory(data_dir, RESULTS_CACHE_COMPONENT_NAME)
        _validate_log_directory(logs_dir, RESULTS_CACHE_COMPONENT_NAME)
    
        validate_port(
            f"{RESULTS_CACHE_COMPONENT_NAME}.port",
            clp_config.results_cache.host,
            clp_config.results_cache.port,
        )
    

  • Snippet: Validation for WebUI config
    • Lines 577-586

    def validate_webui_config(
        clp_config: CLPConfig,
        client_settings_json_path: pathlib.Path,
        server_settings_json_path: pathlib.Path,
    ):
        for path in [client_settings_json_path, server_settings_json_path]:
            if not path.exists():
                raise ValueError(f"{WEBUI_COMPONENT_NAME} {path} is not a valid path to settings.json")
    
        validate_port(f"{WEBUI_COMPONENT_NAME}.port", clp_config.webui.host, clp_config.webui.port)
    

  • Snippet: Deployment type getters (from CLP config utils)
    • Lines 770-774

    def get_deployment_type(self) -> DeploymentType:
        if QueryEngine.PRESTO == self.package.query_engine:
            return DeploymentType.BASE
        else:
            return DeploymentType.FULL